home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / lib / gcc-lib / ppc-amigaos / 2.95.1 / sys-include / powerup / ppcpragmas / expansion_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-03-13  |  12KB  |  421 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_EXPANSION_H
  4. #define _PPCPRAGMA_EXPANSION_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__EXPANSION_H
  7. #include <powerup/ppcinline/expansion.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef EXPANSION_BASE_NAME
  24. #define EXPANSION_BASE_NAME ExpansionBase
  25. #endif /* !EXPANSION_BASE_NAME */
  26.  
  27. #define    AddBootNode(bootPri, flags, deviceNode, configDev)    _AddBootNode(EXPANSION_BASE_NAME, bootPri, flags, deviceNode, configDev)
  28.  
  29. static __inline BOOL
  30. _AddBootNode(void *ExpansionBase, long bootPri, unsigned long flags, struct DeviceNode *deviceNode, struct ConfigDev *configDev)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.d0        =(ULONG) bootPri;
  40.     MyCaos.d1        =(ULONG) flags;
  41.     MyCaos.a0        =(ULONG) deviceNode;
  42.     MyCaos.a1        =(ULONG) configDev;
  43.     MyCaos.caos_Un.Offset    =    (-36);
  44.     MyCaos.a6        =(ULONG) ExpansionBase;    
  45.     return((BOOL)PPCCallOS(&MyCaos));
  46. }
  47.  
  48. #define    AddConfigDev(configDev)    _AddConfigDev(EXPANSION_BASE_NAME, configDev)
  49.  
  50. static __inline void
  51. _AddConfigDev(void *ExpansionBase, struct ConfigDev *configDev)
  52. {
  53. struct Caos    MyCaos;
  54.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  55. //    MyCaos.M68kStart    =    NULL;
  56. //    MyCaos.M68kSize        =    0;
  57.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  58. //    MyCaos.PPCStart        =    NULL;
  59. //    MyCaos.PPCSize        =    0;
  60.     MyCaos.a0        =(ULONG) configDev;
  61.     MyCaos.caos_Un.Offset    =    (-30);
  62.     MyCaos.a6        =(ULONG) ExpansionBase;    
  63.     PPCCallOS(&MyCaos);
  64. }
  65.  
  66. #define    AddDosNode(bootPri, flags, deviceNode)    _AddDosNode(EXPANSION_BASE_NAME, bootPri, flags, deviceNode)
  67.  
  68. static __inline BOOL
  69. _AddDosNode(void *ExpansionBase, long bootPri, unsigned long flags, struct DeviceNode *deviceNode)
  70. {
  71. struct Caos    MyCaos;
  72.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  73. //    MyCaos.M68kStart    =    NULL;
  74. //    MyCaos.M68kSize        =    0;
  75.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  76. //    MyCaos.PPCStart        =    NULL;
  77. //    MyCaos.PPCSize        =    0;
  78.     MyCaos.d0        =(ULONG) bootPri;
  79.     MyCaos.d1        =(ULONG) flags;
  80.     MyCaos.a0        =(ULONG) deviceNode;
  81.     MyCaos.caos_Un.Offset    =    (-150);
  82.     MyCaos.a6        =(ULONG) ExpansionBase;    
  83.     return((BOOL)PPCCallOS(&MyCaos));
  84. }
  85.  
  86. #define    AllocBoardMem(slotSpec)    _AllocBoardMem(EXPANSION_BASE_NAME, slotSpec)
  87.  
  88. static __inline void
  89. _AllocBoardMem(void *ExpansionBase, unsigned long slotSpec)
  90. {
  91. struct Caos    MyCaos;
  92.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  93. //    MyCaos.M68kStart    =    NULL;
  94. //    MyCaos.M68kSize        =    0;
  95.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  96. //    MyCaos.PPCStart        =    NULL;
  97. //    MyCaos.PPCSize        =    0;
  98.     MyCaos.d0        =(ULONG) slotSpec;
  99.     MyCaos.caos_Un.Offset    =    (-42);
  100.     MyCaos.a6        =(ULONG) ExpansionBase;    
  101.     PPCCallOS(&MyCaos);
  102. }
  103.  
  104. #define    AllocConfigDev()    _AllocConfigDev(EXPANSION_BASE_NAME)
  105.  
  106. static __inline struct ConfigDev *
  107. _AllocConfigDev(void *ExpansionBase)
  108. {
  109. struct Caos    MyCaos;
  110.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  111. //    MyCaos.M68kStart    =    NULL;
  112. //    MyCaos.M68kSize        =    0;
  113.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  114. //    MyCaos.PPCStart        =    NULL;
  115. //    MyCaos.PPCSize        =    0;
  116.     MyCaos.caos_Un.Offset    =    (-48);
  117.     MyCaos.a6        =(ULONG) ExpansionBase;    
  118.     return((struct ConfigDev *)PPCCallOS(&MyCaos));
  119. }
  120.  
  121. #define    AllocExpansionMem(numSlots, slotAlign)    _AllocExpansionMem(EXPANSION_BASE_NAME, numSlots, slotAlign)
  122.  
  123. static __inline APTR
  124. _AllocExpansionMem(void *ExpansionBase, unsigned long numSlots, unsigned long slotAlign)
  125. {
  126. struct Caos    MyCaos;
  127.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  128. //    MyCaos.M68kStart    =    NULL;
  129. //    MyCaos.M68kSize        =    0;
  130.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  131. //    MyCaos.PPCStart        =    NULL;
  132. //    MyCaos.PPCSize        =    0;
  133.     MyCaos.d0        =(ULONG) numSlots;
  134.     MyCaos.d1        =(ULONG) slotAlign;
  135.     MyCaos.caos_Un.Offset    =    (-54);
  136.     MyCaos.a6        =(ULONG) ExpansionBase;    
  137.     return((APTR)PPCCallOS(&MyCaos));
  138. }
  139.  
  140. #define    ConfigBoard(board, configDev)    _ConfigBoard(EXPANSION_BASE_NAME, board, configDev)
  141.  
  142. static __inline void
  143. _ConfigBoard(void *ExpansionBase, APTR board, struct ConfigDev *configDev)
  144. {
  145. struct Caos    MyCaos;
  146.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  147. //    MyCaos.M68kStart    =    NULL;
  148. //    MyCaos.M68kSize        =    0;
  149.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  150. //    MyCaos.PPCStart        =    NULL;
  151. //    MyCaos.PPCSize        =    0;
  152.     MyCaos.a0        =(ULONG) board;
  153.     MyCaos.a1        =(ULONG) configDev;
  154.     MyCaos.caos_Un.Offset    =    (-60);
  155.     MyCaos.a6        =(ULONG) ExpansionBase;    
  156.     PPCCallOS(&MyCaos);
  157. }
  158.  
  159. #define    ConfigChain(baseAddr)    _ConfigChain(EXPANSION_BASE_NAME, baseAddr)
  160.  
  161. static __inline void
  162. _ConfigChain(void *ExpansionBase, APTR baseAddr)
  163. {
  164. struct Caos    MyCaos;
  165.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  166. //    MyCaos.M68kStart    =    NULL;
  167. //    MyCaos.M68kSize        =    0;
  168.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  169. //    MyCaos.PPCStart        =    NULL;
  170. //    MyCaos.PPCSize        =    0;
  171.     MyCaos.a0        =(ULONG) baseAddr;
  172.     MyCaos.caos_Un.Offset    =    (-66);
  173.     MyCaos.a6        =(ULONG) ExpansionBase;    
  174.     PPCCallOS(&MyCaos);
  175. }
  176.  
  177. #define    FindConfigDev(oldConfigDev, manufacturer, product)    _FindConfigDev(EXPANSION_BASE_NAME, oldConfigDev, manufacturer, product)
  178.  
  179. static __inline struct ConfigDev *
  180. _FindConfigDev(void *ExpansionBase, struct ConfigDev *oldConfigDev, long manufacturer, long product)
  181. {
  182. struct Caos    MyCaos;
  183.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  184. //    MyCaos.M68kStart    =    NULL;
  185. //    MyCaos.M68kSize        =    0;
  186.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  187. //    MyCaos.PPCStart        =    NULL;
  188. //    MyCaos.PPCSize        =    0;
  189.     MyCaos.a0        =(ULONG) oldConfigDev;
  190.     MyCaos.d0        =(ULONG) manufacturer;
  191.     MyCaos.d1        =(ULONG) product;
  192.     MyCaos.caos_Un.Offset    =    (-72);
  193.     MyCaos.a6        =(ULONG) ExpansionBase;    
  194.     return((struct ConfigDev *)PPCCallOS(&MyCaos));
  195. }
  196.  
  197. #define    FreeBoardMem(startSlot, slotSpec)    _FreeBoardMem(EXPANSION_BASE_NAME, startSlot, slotSpec)
  198.  
  199. static __inline void
  200. _FreeBoardMem(void *ExpansionBase, unsigned long startSlot, unsigned long slotSpec)
  201. {
  202. struct Caos    MyCaos;
  203.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  204. //    MyCaos.M68kStart    =    NULL;
  205. //    MyCaos.M68kSize        =    0;
  206.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  207. //    MyCaos.PPCStart        =    NULL;
  208. //    MyCaos.PPCSize        =    0;
  209.     MyCaos.d0        =(ULONG) startSlot;
  210.     MyCaos.d1        =(ULONG) slotSpec;
  211.     MyCaos.caos_Un.Offset    =    (-78);
  212.     MyCaos.a6        =(ULONG) ExpansionBase;    
  213.     PPCCallOS(&MyCaos);
  214. }
  215.  
  216. #define    FreeConfigDev(configDev)    _FreeConfigDev(EXPANSION_BASE_NAME, configDev)
  217.  
  218. static __inline void
  219. _FreeConfigDev(void *ExpansionBase, struct ConfigDev *configDev)
  220. {
  221. struct Caos    MyCaos;
  222.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  223. //    MyCaos.M68kStart    =    NULL;
  224. //    MyCaos.M68kSize        =    0;
  225.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  226. //    MyCaos.PPCStart        =    NULL;
  227. //    MyCaos.PPCSize        =    0;
  228.     MyCaos.a0        =(ULONG) configDev;
  229.     MyCaos.caos_Un.Offset    =    (-84);
  230.     MyCaos.a6        =(ULONG) ExpansionBase;    
  231.     PPCCallOS(&MyCaos);
  232. }
  233.  
  234. #define    FreeExpansionMem(startSlot, numSlots)    _FreeExpansionMem(EXPANSION_BASE_NAME, startSlot, numSlots)
  235.  
  236. static __inline void
  237. _FreeExpansionMem(void *ExpansionBase, unsigned long startSlot, unsigned long numSlots)
  238. {
  239. struct Caos    MyCaos;
  240.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  241. //    MyCaos.M68kStart    =    NULL;
  242. //    MyCaos.M68kSize        =    0;
  243.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  244. //    MyCaos.PPCStart        =    NULL;
  245. //    MyCaos.PPCSize        =    0;
  246.     MyCaos.d0        =(ULONG) startSlot;
  247.     MyCaos.d1        =(ULONG) numSlots;
  248.     MyCaos.caos_Un.Offset    =    (-90);
  249.     MyCaos.a6        =(ULONG) ExpansionBase;    
  250.     PPCCallOS(&MyCaos);
  251. }
  252.  
  253. #define    GetCurrentBinding(currentBinding, bindingSize)    _GetCurrentBinding(EXPANSION_BASE_NAME, currentBinding, bindingSize)
  254.  
  255. static __inline ULONG
  256. _GetCurrentBinding(void *ExpansionBase, struct CurrentBinding *currentBinding, unsigned long bindingSize)
  257. {
  258. struct Caos    MyCaos;
  259.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  260. //    MyCaos.M68kStart    =    NULL;
  261. //    MyCaos.M68kSize        =    0;
  262.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  263. //    MyCaos.PPCStart        =    NULL;
  264. //    MyCaos.PPCSize        =    0;
  265.     MyCaos.a0        =(ULONG) currentBinding;
  266.     MyCaos.d0        =(ULONG) bindingSize;
  267.     MyCaos.caos_Un.Offset    =    (-138);
  268.     MyCaos.a6        =(ULONG) ExpansionBase;    
  269.     return((ULONG)PPCCallOS(&MyCaos));
  270. }
  271.  
  272. #define    MakeDosNode(parmPacket)    _MakeDosNode(EXPANSION_BASE_NAME, parmPacket)
  273.  
  274. static __inline struct DeviceNode *
  275. _MakeDosNode(void *ExpansionBase, APTR parmPacket)
  276. {
  277. struct Caos    MyCaos;
  278.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  279. //    MyCaos.M68kStart    =    NULL;
  280. //    MyCaos.M68kSize        =    0;
  281.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  282. //    MyCaos.PPCStart        =    NULL;
  283. //    MyCaos.PPCSize        =    0;
  284.     MyCaos.a0        =(ULONG) parmPacket;
  285.     MyCaos.caos_Un.Offset    =    (-144);
  286.     MyCaos.a6        =(ULONG) ExpansionBase;    
  287.     return((struct DeviceNode *)PPCCallOS(&MyCaos));
  288. }
  289.  
  290. #define    ObtainConfigBinding()    _ObtainConfigBinding(EXPANSION_BASE_NAME)
  291.  
  292. static __inline void
  293. _ObtainConfigBinding(void *ExpansionBase)
  294. {
  295. struct Caos    MyCaos;
  296.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  297. //    MyCaos.M68kStart    =    NULL;
  298. //    MyCaos.M68kSize        =    0;
  299.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  300. //    MyCaos.PPCStart        =    NULL;
  301. //    MyCaos.PPCSize        =    0;
  302.     MyCaos.caos_Un.Offset    =    (-120);
  303.     MyCaos.a6        =(ULONG) ExpansionBase;    
  304.     PPCCallOS(&MyCaos);
  305. }
  306.  
  307. #define    ReadExpansionByte(board, offset)    _ReadExpansionByte(EXPANSION_BASE_NAME, board, offset)
  308.  
  309. static __inline UBYTE
  310. _ReadExpansionByte(void *ExpansionBase, APTR board, unsigned long offset)
  311. {
  312. struct Caos    MyCaos;
  313.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  314. //    MyCaos.M68kStart    =    NULL;
  315. //    MyCaos.M68kSize        =    0;
  316.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  317. //    MyCaos.PPCStart        =    NULL;
  318. //    MyCaos.PPCSize        =    0;
  319.     MyCaos.a0        =(ULONG) board;
  320.     MyCaos.d0        =(ULONG) offset;
  321.     MyCaos.caos_Un.Offset    =    (-96);
  322.     MyCaos.a6        =(ULONG) ExpansionBase;    
  323.     return((UBYTE)PPCCallOS(&MyCaos));
  324. }
  325.  
  326. #define    ReadExpansionRom(board, configDev)    _ReadExpansionRom(EXPANSION_BASE_NAME, board, configDev)
  327.  
  328. static __inline void
  329. _ReadExpansionRom(void *ExpansionBase, APTR board, struct ConfigDev *configDev)
  330. {
  331. struct Caos    MyCaos;
  332.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  333. //    MyCaos.M68kStart    =    NULL;
  334. //    MyCaos.M68kSize        =    0;
  335.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  336. //    MyCaos.PPCStart        =    NULL;
  337. //    MyCaos.PPCSize        =    0;
  338.     MyCaos.a0        =(ULONG) board;
  339.     MyCaos.a1        =(ULONG) configDev;
  340.     MyCaos.caos_Un.Offset    =    (-102);
  341.     MyCaos.a6        =(ULONG) ExpansionBase;    
  342.     PPCCallOS(&MyCaos);
  343. }
  344.  
  345. #define    ReleaseConfigBinding()    _ReleaseConfigBinding(EXPANSION_BASE_NAME)
  346.  
  347. static __inline void
  348. _ReleaseConfigBinding(void *ExpansionBase)
  349. {
  350. struct Caos    MyCaos;
  351.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  352. //    MyCaos.M68kStart    =    NULL;
  353. //    MyCaos.M68kSize        =    0;
  354.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  355. //    MyCaos.PPCStart        =    NULL;
  356. //    MyCaos.PPCSize        =    0;
  357.     MyCaos.caos_Un.Offset    =    (-126);
  358.     MyCaos.a6        =(ULONG) ExpansionBase;    
  359.     PPCCallOS(&MyCaos);
  360. }
  361.  
  362. #define    RemConfigDev(configDev)    _RemConfigDev(EXPANSION_BASE_NAME, configDev)
  363.  
  364. static __inline void
  365. _RemConfigDev(void *ExpansionBase, struct ConfigDev *configDev)
  366. {
  367. struct Caos    MyCaos;
  368.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  369. //    MyCaos.M68kStart    =    NULL;
  370. //    MyCaos.M68kSize        =    0;
  371.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  372. //    MyCaos.PPCStart        =    NULL;
  373. //    MyCaos.PPCSize        =    0;
  374.     MyCaos.a0        =(ULONG) configDev;
  375.     MyCaos.caos_Un.Offset    =    (-108);
  376.     MyCaos.a6        =(ULONG) ExpansionBase;    
  377.     PPCCallOS(&MyCaos);
  378. }
  379.  
  380. #define    SetCurrentBinding(currentBinding, bindingSize)    _SetCurrentBinding(EXPANSION_BASE_NAME, currentBinding, bindingSize)
  381.  
  382. static __inline void
  383. _SetCurrentBinding(void *ExpansionBase, struct CurrentBinding *currentBinding, unsigned long bindingSize)
  384. {
  385. struct Caos    MyCaos;
  386.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  387. //    MyCaos.M68kStart    =    NULL;
  388. //    MyCaos.M68kSize        =    0;
  389.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  390. //    MyCaos.PPCStart        =    NULL;
  391. //    MyCaos.PPCSize        =    0;
  392.     MyCaos.a0        =(ULONG) currentBinding;
  393.     MyCaos.d0        =(ULONG) bindingSize;
  394.     MyCaos.caos_Un.Offset    =    (-132);
  395.     MyCaos.a6        =(ULONG) ExpansionBase;    
  396.     PPCCallOS(&MyCaos);
  397. }
  398.  
  399. #define    WriteExpansionByte(board, offset, byte)    _WriteExpansionByte(EXPANSION_BASE_NAME, board, offset, byte)
  400.  
  401. static __inline void
  402. _WriteExpansionByte(void *ExpansionBase, APTR board, unsigned long offset, unsigned long byte)
  403. {
  404. struct Caos    MyCaos;
  405.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  406. //    MyCaos.M68kStart    =    NULL;
  407. //    MyCaos.M68kSize        =    0;
  408.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  409. //    MyCaos.PPCStart        =    NULL;
  410. //    MyCaos.PPCSize        =    0;
  411.     MyCaos.a0        =(ULONG) board;
  412.     MyCaos.d0        =(ULONG) offset;
  413.     MyCaos.d1        =(ULONG) byte;
  414.     MyCaos.caos_Un.Offset    =    (-114);
  415.     MyCaos.a6        =(ULONG) ExpansionBase;    
  416.     PPCCallOS(&MyCaos);
  417. }
  418.  
  419. #endif /* SASC Pragmas */
  420. #endif /* !_PPCPRAGMA_EXPANSION_H */
  421.